ViewModel
Architecture

class MainViewModel : ViewModel() {

    // viewModelScope is automatically cancelled in onCleared()
    init {
        viewModelScope.launch {
            repo.streamUpdates().collect { update ->
                _state.update { it.copy(data = update) }
            }
        }
    }

    // Rare — only for non-viewModelScope resources
    private val bluetoothListener = BluetoothListener()

    override fun onCleared() {
        super.onCleared()
        // Called ONCE, only when scope is permanently destroyed
        // NOT called on rotation
        bluetoothListener.unregister()
    }
}

// Simplified from AndroidX source — it really is this simple
class ViewModelStore {

    private val map = HashMap<String, ViewModel>()

    fun put(key: String, viewModel: ViewModel) {
        val oldVM = map.put(key, viewModel)
        oldVM?.onCleared()   // clear replaced VM
    }

    fun get(key: String): ViewModel? = map[key]

    fun keys(): Set<String> = map.keys.toHashSet()

    // Called by the owner when it's truly finishing
    fun clear() {
        for (vm in map.values) vm.onCleared()
        map.clear()
    }
}

// The key format used by ViewModelProvider
private const val DEFAULT_KEY =
    "androidx.lifecycle.ViewModelProvider.DefaultKey"
// Full key: "$DEFAULT_KEY:${viewModelClass.canonicalName}"

// The entire interface — just one property
interface ViewModelStoreOwner {
    val viewModelStore: ViewModelStore
}

// ComponentActivity implements it like this:
class ComponentActivity : ViewModelStoreOwner, ... {

    private var _viewModelStore: ViewModelStore? = null

    override val viewModelStore: ViewModelStore
        get() {
            if (_viewModelStore == null) {
                // Try to restore from non-config instance (rotation)
                val nc = lastNonConfigurationInstance
                if (nc is NonConfigurationInstances) {
                    _viewModelStore = nc.viewModelStore
                }
                if (_viewModelStore == null) {
                    _viewModelStore = ViewModelStore()  // fresh start
                }
            }
            return _viewModelStore!!
        }

    override fun onDestroy() {
        super.onDestroy()
        if (!isChangingConfigurations()) {
            // Permanently finishing — clear the store
            viewModelStore.clear()
        }
        // If isChangingConfigurations() — store is kept!
    }
}

// Simplified ViewModelProvider.get() logic
fun <T : ViewModel> get(modelClass: KClass<T>): T {
    val canonicalName = modelClass.java.canonicalName
        ?: throw IllegalArgumentException("Local and anonymous classes can't be ViewModels")
    val key = "$DEFAULT_KEY:$canonicalName"
    return get(key, modelClass)
}

fun <T : ViewModel> get(key: String, modelClass: KClass<T>): T {
    val viewModel = store.get(key)
    if (modelClass.isInstance(viewModel)) {
        return viewModel as T   // ← found in store, return existing
    }
    // Not found — create via factory
    val newVM = factory.create(modelClass, extras)
    store.put(key, newVM)
    return newVM
}

// Usage variants

// 1. No-arg ViewModel (Hilt or reflection-based)
val vm: MainViewModel by viewModels()

// 2. Custom factory (manual DI)
val vm: MainViewModel by viewModels {
    MainViewModelFactory(repository)
}

// 3. Custom key (multiple instances of same class)
val vm1 = ViewModelProvider(this).get("player_1", PlayerViewModel::class)
val vm2 = ViewModelProvider(this).get("player_2", PlayerViewModel::class)

class MyViewModelFactory(
    private val repo: UserRepository
) : ViewModelProvider.Factory {

    override fun <T : ViewModel> create(
        modelClass: Class<T>,
        extras: CreationExtras
    ): T {
        // Extract standard extras
        val application = extras[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY]!!
        val savedStateHandle = extras.createSavedStateHandle()

        return when (modelClass) {
            MainViewModel::class.java ->
                MainViewModel(repo, savedStateHandle) as T
            else -> throw IllegalArgumentException("Unknown VM class")
        }
    }

    companion object {
        // The modern recommended factory pattern
        val Factory = viewModelFactory {
            initializer {
                val app = this[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY]!!
                val handle = createSavedStateHandle()
                val repo = (app as MyApp).appComponent.userRepository
                MainViewModel(repo, handle)
            }
        }
    }
}

// 1. Fragment-scoped (private to this fragment)
val vm: ProfileViewModel by viewModels()

// 2. Activity-scoped (shared with all siblings)
val sharedVm: SharedViewModel by activityViewModels()

// 3. NavGraph-scoped (shared within checkout flow)
val checkoutVm: CheckoutViewModel by navGraphViewModels(R.id.checkout_graph)

// 4. NavBackStackEntry-scoped (explicit destination)
val entry = findNavController().getBackStackEntry(R.id.cartFragment)
val cartVm: CartViewModel by viewModels({ entry })

// 5. Multiple instances of the same VM class
val player1Vm = ViewModelProvider(this).get("player_1", PlayerViewModel::class.java)
val player2Vm = ViewModelProvider(this).get("player_2", PlayerViewModel::class.java)

// 6. Compose — hiltViewModel() uses LocalViewModelStoreOwner
@Composable
fun ProfileScreen() {
    val vm: ProfileViewModel = hiltViewModel()          // NavEntry scope
    val sharedVm: SharedViewModel = hiltViewModel(       // Activity scope
        viewModelStoreOwner = LocalContext.current as ViewModelStoreOwner
    )
}

// ViewModel — annotate with @HiltViewModel, inject with @Inject
@HiltViewModel
class OrderViewModel @Inject constructor(
    private val orderRepo: OrderRepository,
    private val userRepo: UserRepository,
    private val analytics: AnalyticsTracker,
    private val savedState: SavedStateHandle   // auto-injected by Hilt
) : ViewModel() {

    val orders = orderRepo.getOrders()
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())
}

// Fragment — just annotate with @AndroidEntryPoint
@AndroidEntryPoint
class OrderFragment : Fragment() {
    val viewModel: OrderViewModel by viewModels()   // Hilt provides it
}

// Activity-scoped shared ViewModel
@AndroidEntryPoint
class CheckoutFragment : Fragment() {
    val cartVm: CartViewModel by activityViewModels()
}

// Assisted injection — for dynamic parameters at creation time
@HiltViewModel(assistedFactory = DetailViewModel.Factory::class)
class DetailViewModel @AssistedInject constructor(
    @Assisted val itemId: String,  // provided at runtime
    private val repo: ItemRepository  // from DI graph
) : ViewModel() {
    @AssistedFactory
    interface Factory {
        fun create(itemId: String): DetailViewModel
    }
}

@HiltViewModel
class SearchViewModel @Inject constructor(
    private val handle: SavedStateHandle,
    private val searchRepo: SearchRepository
) : ViewModel() {

    // Pattern 1: Simple get/set — survives rotation + process death
    var query: String
        get() = handle["query"] ?: ""
        set(v) { handle["query"] = v }

    // Pattern 2: StateFlow backed by SavedStateHandle
    // ← this is the recommended modern pattern
    val queryFlow: StateFlow<String> =
        handle.getStateFlow("query", "")

    // Setting updates the StateFlow AND persists to bundle
    fun onQueryChanged(q: String) {
        handle["query"] = q   // triggers queryFlow emission
    }

    // Pattern 3: Drive a search from the persisted query
    val results: StateFlow<SearchState> =
        handle.getStateFlow("query", "")
            .debounce(300)
            .distinctUntilChanged()
            .flatMapLatest { q ->
                if (q.isBlank()) flowOf(SearchState.Empty)
                else searchRepo.search(q).map { SearchState.Results(it) }
            }
            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), SearchState.Empty)

    // Pattern 4: Reading Navigation arguments automatically
    // Navigation passes destination args to SavedStateHandle
    val orderId: String = handle.get<String>("orderId")!!
    // Or with the generated nav args type
    val args = OrderDetailArgs.fromSavedStateHandle(handle)
}

@HiltViewModel
class ArticleViewModel @Inject constructor(
    private val repo: ArticleRepository,
    private val savedState: SavedStateHandle
) : ViewModel() {

    // ── State (UI observable) ──────────────────────────────────
    val uiState: StateFlow<ArticleUiState> =
        savedState.getStateFlow("filter", Filter.All)
            .flatMapLatest { filter -> repo.getArticles(filter) }
            .map { articles -> ArticleUiState.Success(articles) }
            .catch { e -> emit(ArticleUiState.Error(e.message)) }
            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), ArticleUiState.Loading)

    // ── One-shot events (navigation, snackbar) ─────────────────
    private val _events = MutableSharedFlow<ArticleEvent>(extraBufferCapacity = 1)
    val events = _events.asSharedFlow()

    // ── User actions ───────────────────────────────────────────
    fun onFilterChanged(filter: Filter) {
        savedState["filter"] = filter
    }

    fun onArticleClicked(article: Article) {
        viewModelScope.launch {
            _events.emit(ArticleEvent.Navigate("articles/${article.id}"))
        }
    }

    fun onBookmarkClicked(article: Article) {
        viewModelScope.launch {
            repo.toggleBookmark(article.id)
            _events.tryEmit(ArticleEvent.ShowSnackbar("Bookmarked"))
        }
    }
}

// ── Sealed UI state ────────────────────────────────────────────
sealed class ArticleUiState {
    data object Loading : ArticleUiState()
    data class Success(val articles: List<Article>) : ArticleUiState()
    data class Error(val message: String?) : ArticleUiState()
}

// ── Fragment collection ────────────────────────────────────────
viewLifecycleOwner.lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        launch {
            viewModel.uiState.collect { state ->
                when (state) {
                    is ArticleUiState.Loading  -> showLoading()
                    is ArticleUiState.Success  -> adapter.submitList(state.articles)
                    is ArticleUiState.Error    -> showError(state.message)
                }
            }
        }
        launch {
            viewModel.events.collect { event ->
                when (event) {
                    is ArticleEvent.Navigate     -> navigate(event.route)
                    is ArticleEvent.ShowSnackbar -> showSnackbar(event.msg)
                }
            }
        }
    }
}

@OptIn(ExperimentalCoroutinesApi::class)
class ArticleViewModelTest {

    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()

    private val fakeRepo = FakeArticleRepository()
    private val savedState = SavedStateHandle()

    private lateinit var viewModel: ArticleViewModel

    @Before
    fun setup() {
        viewModel = ArticleViewModel(fakeRepo, savedState)
    }

    @Test
    fun `filter change loads correct articles`() = runTest {
        val states = mutableListOf<ArticleUiState>()
        val job = launch(UnconfinedTestDispatcher()) {
            viewModel.uiState.toList(states)
        }
        viewModel.onFilterChanged(Filter.Bookmarked)
        assertEquals(Filter.Bookmarked, fakeRepo.lastFilter)
        job.cancel()
    }
}